home *** CD-ROM | disk | FTP | other *** search
/ Cream of the Crop 26 / Cream of the Crop 26.iso / program / nasm095s.zip / OUTAOUT.C < prev    next >
C/C++ Source or Header  |  1997-07-27  |  13KB  |  468 lines
  1. /* outaout.c    output routines for the Netwide Assembler to produce
  2.  *        Linux a.out object files
  3.  *
  4.  * The Netwide Assembler is copyright (C) 1996 Simon Tatham and
  5.  * Julian Hall. All rights reserved. The software is
  6.  * redistributable under the licence given in the file "Licence"
  7.  * distributed in the NASM archive.
  8.  */
  9.  
  10. #include <stdio.h>
  11. #include <stdlib.h>
  12. #include <string.h>
  13. #include <ctype.h>
  14.  
  15. #include "nasm.h"
  16. #include "nasmlib.h"
  17. #include "outform.h"
  18.  
  19. #ifdef OF_AOUT
  20.  
  21. struct Reloc {
  22.     struct Reloc *next;
  23.     long address;               /* relative to _start_ of section */
  24.     long symbol;               /* symbol number or -ve section id */
  25.     int bytes;                   /* 2 or 4 */
  26.     int relative;               /* TRUE or FALSE */
  27. };
  28.  
  29. struct Symbol {
  30.     long strpos;               /* string table position of name */
  31.     int type;                   /* symbol type - see flags below */
  32.     long value;                   /* address, or COMMON variable size */
  33. };
  34.  
  35. /*
  36.  * Section IDs - used in Reloc.symbol when negative, and in
  37.  * Symbol.type when positive.
  38.  */
  39. #define SECT_ABS 2               /* absolute value */
  40. #define SECT_TEXT 4               /* text section */
  41. #define SECT_DATA 6               /* data section */
  42. #define SECT_BSS 8               /* bss section */
  43. #define SECT_MASK 0xE               /* mask out any of the above */
  44.  
  45. /*
  46.  * Another flag used in Symbol.type.
  47.  */
  48. #define SYM_GLOBAL 1               /* it's a global symbol */
  49.  
  50. /*
  51.  * Bit more explanation of symbol types: SECT_xxx denotes a local
  52.  * symbol. SECT_xxx|SYM_GLOBAL denotes a global symbol, defined in
  53.  * this module. Just SYM_GLOBAL, with zero value, denotes an
  54.  * external symbol referenced in this module. And just SYM_GLOBAL,
  55.  * but with a non-zero value, declares a C `common' variable, of
  56.  * size `value'.
  57.  */
  58.  
  59. struct Section {
  60.     struct SAA *data;
  61.     unsigned long len, size, nrelocs;
  62.     long index;
  63.     struct Reloc *head, **tail;
  64. };
  65.  
  66. static struct Section stext, sdata;
  67. static unsigned long bsslen;
  68. static long bssindex;
  69.  
  70. static struct SAA *syms;
  71. static unsigned long nsyms;
  72.  
  73. static struct RAA *bsym;
  74.  
  75. static struct SAA *strs;
  76. static unsigned long strslen;
  77.  
  78. static FILE *aoutfp;
  79. static efunc error;
  80.  
  81. static void aout_write(void);
  82. static void aout_write_relocs(struct Reloc *);
  83. static void aout_write_syms(void);
  84. static void aout_sect_write(struct Section *, unsigned char *, unsigned long);
  85. static void aout_pad_sections(void);
  86. static void aout_fixup_relocs(struct Section *);
  87.  
  88. static void aout_init(FILE *fp, efunc errfunc, ldfunc ldef) {
  89.     aoutfp = fp;
  90.     error = errfunc;
  91.     (void) ldef;               /* placate optimisers */
  92.     stext.data = saa_init(1L); stext.head = NULL; stext.tail = &stext.head;
  93.     sdata.data = saa_init(1L); sdata.head = NULL; sdata.tail = &sdata.head;
  94.     stext.len = stext.size = sdata.len = sdata.size = bsslen = 0;
  95.     stext.nrelocs = sdata.nrelocs = 0;
  96.     stext.index = seg_alloc();
  97.     sdata.index = seg_alloc();
  98.     bssindex = seg_alloc();
  99.     syms = saa_init((long)sizeof(struct Symbol));
  100.     nsyms = 0;
  101.     bsym = raa_init();
  102.     strs = saa_init(1L);
  103.     strslen = 0;
  104. }
  105.  
  106. static void aout_cleanup(void) {
  107.     struct Reloc *r;
  108.  
  109.     aout_pad_sections();
  110.     aout_fixup_relocs(&stext);
  111.     aout_fixup_relocs(&sdata);
  112.     aout_write();
  113.     fclose (aoutfp);
  114.     saa_free (stext.data);
  115.     while (stext.head) {
  116.     r = stext.head;
  117.     stext.head = stext.head->next;
  118.     nasm_free (r);
  119.     }
  120.     saa_free (sdata.data);
  121.     while (sdata.head) {
  122.     r = sdata.head;
  123.     sdata.head = sdata.head->next;
  124.     nasm_free (r);
  125.     }
  126.     saa_free (syms);
  127.     raa_free (bsym);
  128.     saa_free (strs);
  129. }
  130.  
  131. static long aout_section_names (char *name, int pass, int *bits) {
  132.     /*
  133.      * Default to 32 bits.
  134.      */
  135.     if (!name)
  136.     *bits = 32;
  137.  
  138.     if (!name)
  139.     return stext.index;
  140.  
  141.     if (!strcmp(name, ".text"))
  142.     return stext.index;
  143.     else if (!strcmp(name, ".data"))
  144.     return sdata.index;
  145.     else if (!strcmp(name, ".bss"))
  146.     return bssindex;
  147.     else
  148.     return NO_SEG;
  149. }
  150.  
  151. static void aout_deflabel (char *name, long segment, long offset,
  152.                int is_global) {
  153.     int pos = strslen+4;
  154.     struct Symbol *sym;
  155.  
  156.     if (name[0] == '.' && name[1] == '.' && name[2] != '@') {
  157.     error (ERR_NONFATAL, "unrecognised special symbol `%s'", name);
  158.     return;
  159.     }
  160.  
  161.     saa_wbytes (strs, name, (long)(1+strlen(name)));
  162.     strslen += 1+strlen(name);
  163.  
  164.     sym = saa_wstruct (syms);
  165.  
  166.     sym->strpos = pos;
  167.     sym->type = is_global ? SYM_GLOBAL : 0;
  168.     if (segment == NO_SEG)
  169.     sym->type |= SECT_ABS;
  170.     else if (segment == stext.index)
  171.     sym->type |= SECT_TEXT;
  172.     else if (segment == sdata.index)
  173.     sym->type |= SECT_DATA;
  174.     else if (segment == bssindex)
  175.     sym->type |= SECT_BSS;
  176.     else
  177.     sym->type = SYM_GLOBAL;
  178.     if (is_global == 2)
  179.     sym->value = offset;
  180.     else
  181.     sym->value = (sym->type == SYM_GLOBAL ? 0 : offset);
  182.  
  183.     /*
  184.      * define the references from external-symbol segment numbers
  185.      * to these symbol records.
  186.      */
  187.     if (segment != NO_SEG && segment != stext.index &&
  188.     segment != sdata.index && segment != bssindex)
  189.     bsym = raa_write (bsym, segment, nsyms);
  190.  
  191.     nsyms++;
  192. }
  193.  
  194. static void aout_add_reloc (struct Section *sect, long segment,
  195.                 int relative, int bytes) {
  196.     struct Reloc *r;
  197.  
  198.     r = *sect->tail = nasm_malloc(sizeof(struct Reloc));
  199.     sect->tail = &r->next;
  200.     r->next = NULL;
  201.  
  202.     r->address = sect->len;
  203.     r->symbol = (segment == NO_SEG ? -SECT_ABS :
  204.          segment == stext.index ? -SECT_TEXT :
  205.          segment == sdata.index ? -SECT_DATA :
  206.          segment == bssindex ? -SECT_BSS :
  207.          raa_read(bsym, segment));
  208.     r->relative = relative;
  209.     r->bytes = bytes;
  210.  
  211.     sect->nrelocs++;
  212. }
  213.  
  214. static void aout_out (long segto, void *data, unsigned long type,
  215.               long segment, long wrt) {
  216.     struct Section *s;
  217.     long realbytes = type & OUT_SIZMASK;
  218.     unsigned char mydata[4], *p;
  219.  
  220.     if (wrt != NO_SEG) {
  221.     wrt = NO_SEG;               /* continue to do _something_ */
  222.     error (ERR_NONFATAL, "WRT not supported by a.out output format");
  223.     }
  224.  
  225.     type &= OUT_TYPMASK;
  226.  
  227.     /*
  228.      * handle absolute-assembly (structure definitions)
  229.      */
  230.     if (segto == NO_SEG) {
  231.     if (type != OUT_RESERVE)
  232.         error (ERR_NONFATAL, "attempt to assemble code in [ABSOLUTE]"
  233.            " space");
  234.     return;
  235.     }
  236.  
  237.     if (segto == stext.index)
  238.     s = &stext;
  239.     else if (segto == sdata.index)
  240.     s = &sdata;
  241.     else if (segto == bssindex)
  242.     s = NULL;
  243.     else {
  244.     error(ERR_WARNING, "attempt to assemble code in"
  245.           " segment %d: defaulting to `.text'", segto);
  246.     s = &stext;
  247.     }
  248.  
  249.     if (!s && type != OUT_RESERVE) {
  250.     error(ERR_WARNING, "attempt to initialise memory in the"
  251.           " BSS section: ignored");
  252.     if (type == OUT_REL2ADR)
  253.         realbytes = 2;
  254.     else if (type == OUT_REL4ADR)
  255.         realbytes = 4;
  256.     bsslen += realbytes;
  257.     return;
  258.     }
  259.  
  260.     if (type == OUT_RESERVE) {
  261.     if (s) {
  262.         error(ERR_WARNING, "uninitialised space declared in"
  263.           " %s section: zeroing",
  264.           (segto == stext.index ? "code" : "data"));
  265.         aout_sect_write (s, NULL, realbytes);
  266.     } else
  267.         bsslen += realbytes;
  268.     } else if (type == OUT_RAWDATA) {
  269.     if (segment != NO_SEG)
  270.         error(ERR_PANIC, "OUT_RAWDATA with other than NO_SEG");
  271.     aout_sect_write (s, data, realbytes);
  272.     } else if (type == OUT_ADDRESS) {
  273.     if (segment != NO_SEG) {
  274.         if (segment % 2) {
  275.         error(ERR_NONFATAL, "a.out format does not support"
  276.               " segment base references");
  277.         } else
  278.         aout_add_reloc (s, segment, FALSE, realbytes);
  279.     }
  280.     p = mydata;
  281.     if (realbytes == 2)
  282.         WRITESHORT (p, *(long *)data);
  283.     else
  284.         WRITELONG (p, *(long *)data);
  285.     aout_sect_write (s, mydata, realbytes);
  286.     } else if (type == OUT_REL2ADR) {
  287.     if (segment == segto)
  288.         error(ERR_PANIC, "intra-segment OUT_REL2ADR");
  289.     if (segment != NO_SEG && segment % 2) {
  290.         error(ERR_NONFATAL, "a.out format does not support"
  291.           " segment base references");
  292.     } else
  293.         aout_add_reloc (s, segment, TRUE, 2);
  294.     p = mydata;
  295.     WRITESHORT (p, *(long*)data-(realbytes + s->len));
  296.     aout_sect_write (s, mydata, 2L);
  297.     } else if (type == OUT_REL4ADR) {
  298.     if (segment == segto)
  299.         error(ERR_PANIC, "intra-segment OUT_REL4ADR");
  300.     if (segment != NO_SEG && segment % 2) {
  301.         error(ERR_NONFATAL, "a.out format does not support"
  302.           " segment base references");
  303.     } else
  304.         aout_add_reloc (s, segment, TRUE, 4);
  305.     p = mydata;
  306.     WRITELONG (p, *(long*)data-(realbytes + s->len));
  307.     aout_sect_write (s, mydata, 4L);
  308.     }
  309. }
  310.  
  311. static void aout_pad_sections(void) {
  312.     static unsigned char pad[] = { 0x90, 0x90, 0x90, 0x90 };
  313.     /*
  314.      * Pad each of the text and data sections with NOPs until their
  315.      * length is a multiple of four. (NOP == 0x90.) Also increase
  316.      * the length of the BSS section similarly.
  317.      */
  318.     aout_sect_write (&stext, pad, (-stext.len) & 3);
  319.     aout_sect_write (&sdata, pad, (-sdata.len) & 3);
  320.     bsslen = (bsslen + 3) & ~3;
  321. }
  322.  
  323. /*
  324.  * a.out files have the curious property that all references to
  325.  * things in the data or bss sections are done by addresses which
  326.  * are actually relative to the start of the _text_ section, in the
  327.  * _file_. (No relation to what happens after linking. No idea why
  328.  * this should be so. It's very strange.) So we have to go through
  329.  * the relocation table, _after_ the final size of each section is
  330.  * known, and fix up the relocations pointed to.
  331.  */
  332. static void aout_fixup_relocs(struct Section *sect) {
  333.     struct Reloc *r;
  334.  
  335.     saa_rewind (sect->data);
  336.     for (r = sect->head; r; r = r->next) {
  337.     unsigned char *p, *q, blk[4];
  338.     long l;
  339.  
  340.     saa_fread (sect->data, r->address, blk, (long)r->bytes);
  341.     p = q = blk;
  342.     l = *p++;
  343.     l += ((long)*p++) << 8;
  344.     if (r->bytes == 4) {
  345.         l += ((long)*p++) << 16;
  346.         l += ((long)*p++) << 24;
  347.     }
  348.     if (r->symbol == -SECT_DATA)
  349.         l += stext.len;
  350.     else if (r->symbol == -SECT_BSS)
  351.         l += stext.len + sdata.len;
  352.     if (r->bytes == 4)
  353.         WRITELONG(q, l);
  354.     else
  355.         WRITESHORT(q, l);
  356.     saa_fwrite (sect->data, r->address, blk, (long)r->bytes);
  357.     }
  358. }
  359.  
  360. static void aout_write(void) {
  361.     /*
  362.      * Emit the a.out header.
  363.      */
  364.     fwritelong (0x640107L, aoutfp);    /* OMAGIC, M_386, no flags */
  365.     fwritelong (stext.len, aoutfp);
  366.     fwritelong (sdata.len, aoutfp);
  367.     fwritelong (bsslen, aoutfp);
  368.     fwritelong (nsyms * 12, aoutfp);   /* length of symbol table */
  369.     fwritelong (0L, aoutfp);           /* object files have no entry point */
  370.     fwritelong (stext.nrelocs * 8, aoutfp);   /* size of text relocs */
  371.     fwritelong (sdata.nrelocs * 8, aoutfp);   /* size of data relocs */
  372.  
  373.     /*
  374.      * Write out the code section and the data section.
  375.      */
  376.     saa_fpwrite (stext.data, aoutfp);
  377.     saa_fpwrite (sdata.data, aoutfp);
  378.  
  379.     /*
  380.      * Write out the relocations.
  381.      */
  382.     aout_write_relocs (stext.head);
  383.     aout_write_relocs (sdata.head);
  384.  
  385.     /*
  386.      * Write the symbol table.
  387.      */
  388.     aout_write_syms ();
  389.  
  390.     /*
  391.      * And the string table.
  392.      */
  393.     fwritelong (strslen+4, aoutfp);    /* length includes length count */
  394.     saa_fpwrite (strs, aoutfp);
  395. }
  396.  
  397. static void aout_write_relocs (struct Reloc *r) {
  398.     while (r) {
  399.     unsigned long word2;
  400.  
  401.     fwritelong (r->address, aoutfp);
  402.  
  403.     if (r->symbol >= 0)
  404.         word2 = r->symbol | 0x8000000L;
  405.     else
  406.         word2 = -r->symbol;
  407.     if (r->relative)
  408.         word2 |= 0x1000000L;
  409.     word2 |= (r->bytes == 2 ? 0x2000000L : 0x4000000L);
  410.     fwritelong (word2, aoutfp);
  411.  
  412.     r = r->next;
  413.     }
  414. }
  415.  
  416. static void aout_write_syms (void) {
  417.     int i;
  418.  
  419.     saa_rewind (syms);
  420.     for (i=0; i<nsyms; i++) {
  421.     struct Symbol *sym = saa_rstruct(syms);
  422.     fwritelong (sym->strpos, aoutfp);
  423.     fwritelong ((long)sym->type, aoutfp);
  424.     /*
  425.      * Fix up the symbol value now we know the final section
  426.      * sizes.
  427.      */
  428.     if ((sym->type & SECT_MASK) == SECT_DATA)
  429.         sym->value += stext.len;
  430.     if ((sym->type & SECT_MASK) == SECT_BSS)
  431.         sym->value += stext.len + sdata.len;
  432.     fwritelong (sym->value, aoutfp);
  433.     }
  434. }
  435.  
  436. static void aout_sect_write (struct Section *sect,
  437.                  unsigned char *data, unsigned long len) {
  438.     saa_wbytes (sect->data, data, len);
  439.     sect->len += len;
  440. }
  441.  
  442. static long aout_segbase (long segment) {
  443.     return segment;
  444. }
  445.  
  446. static int aout_directive (char *directive, char *value, int pass) {
  447.     return 0;
  448. }
  449.  
  450. static void aout_filename (char *inname, char *outname, efunc error) {
  451.     standard_extension (inname, outname, ".o", error);
  452. }
  453.  
  454. struct ofmt of_aout = {
  455.     "GNU a.out (i386) object files (e.g. Linux)",
  456.     "aout",
  457.     aout_init,
  458.     aout_out,
  459.     aout_deflabel,
  460.     aout_section_names,
  461.     aout_segbase,
  462.     aout_directive,
  463.     aout_filename,
  464.     aout_cleanup
  465. };
  466.  
  467. #endif /* OF_AOUT */
  468.